
#include "testcase.h"
#include "../coord.h"

using namespace Tester;

class CoordTest : public TestCase<CoordTest> {
   public:
      CoordTest() : TestCase<CoordTest>("Test de la clase Coord", __FILE__) {
         add("Constructor por default", &CoordTest::constructordefault);
         add("Gets y Sets", &CoordTest::getSet);
         add("Conversion desde y hacia un array", &CoordTest::conversionArray);
         add("Suma de coordenadas", &CoordTest::suma);
         add("Resta de coordenadas", &CoordTest::resta);
         add("Multiplicacion por un escalar", &CoordTest::escalar);
         add("Normalizacion de coordenadas", &CoordTest::normalizar);
      }

      void normalizar() {
         Coord p1(3, 4, 0);
         Coord p2 = p1.normalizar() * 5; //Vector normalizado multiplicado por su norma

         assertTrue(p2.x() == 3, __LINE__);
         assertTrue(p2.y() == 4, __LINE__);
         assertTrue(p2.z() == 0, __LINE__);
      }

      void suma() {
         Coord p1(0, 1, 2);
         Coord p2(2, 4, -3);

         Coord sum = p1 + p2;

         assertTrue(sum.x() == 2, __LINE__);
         assertTrue(sum.y() == 5, __LINE__);
         assertTrue(sum.z() == -1, __LINE__);

         p1 += p2;

         assertTrue(sum.x() == p1.x(), __LINE__);
         assertTrue(sum.y() == p1.y(), __LINE__);
         assertTrue(sum.z() == p1.z(), __LINE__);
      }

      void resta() {
         Coord p1(0, 1, 2);
         Coord p2(2, 4, -3);

         Coord dif = p1 - p2;

         assertTrue(dif.x() == -2, __LINE__);
         assertTrue(dif.y() == -3, __LINE__);
         assertTrue(dif.z() == 5, __LINE__);
      }

      void escalar() {
         Coord p1(1, 2, 3);

         Coord p2 = p1 * 2;
         Coord p3 = 3 * p1;

         assertTrue(p2.x() == 2, __LINE__);
         assertTrue(p2.y() == 4, __LINE__);
         assertTrue(p2.z() == 6, __LINE__);

         assertTrue(p3.x() == 3, __LINE__);
         assertTrue(p3.y() == 6, __LINE__);
         assertTrue(p3.z() == 9, __LINE__);
      }


      void constructordefault() {
         Coord p1;

         assertTrue(p1.x() == 0, __LINE__);
         assertTrue(p1.y() == 0, __LINE__);
         assertTrue(p1.z() == 0, __LINE__);
      }

      void getSet() {
         Coord p1;

         p1.x() = 2;
         assertTrue(p1.x() == 2, __LINE__);

         p1.y() = 3;
         assertTrue(p1.y() == 3, __LINE__);

         p1.z() = 4;
         assertTrue(p1.z() == 4, __LINE__);
      }

      void conversionArray() {
         Coord p1(0, 1, 2);

         const float *f = p1;
         for(int i = 0; i < 3; ++i)
            assertTrue(int(f[i]) == i, __LINE__);

         float g[3] = {0, -1, -2};

         Coord p2(g);
         p1 = g;

         assertTrue(int(p2.x()) == 0, __LINE__);
         assertTrue(int(p1.x()) == 0, __LINE__);

         assertTrue(int(p2.y()) == -1, __LINE__);
         assertTrue(int(p1.y()) == -1, __LINE__);

         assertTrue(int(p2.z()) == -2, __LINE__);
         assertTrue(int(p1.z()) == -2, __LINE__);
      }
};

namespace {
   CoordTest test;
}

